…1313)

Extends the TypeScript resolution benchmark hierarchy fixture with
Ellipse extends Circle (Shape → Circle → Ellipse) and makeEllipse to
provide RTA evidence. Adds the transitive Shape.describe → Ellipse.area
expected edge, validating the BFS-based runChaPostPass expansion.

Closes #1313

…doc, and tests

…ks (JS)

Phase 8.3e — array-element points-to analysis for JS/TS.

Closes #1321

## What's resolved

`f(...arr)`, `for (x of arr)`, `Array.from(arr, cb)`, and
`new Set(arr)` patterns now produce call edges where function
references flow through array operations:

  const arr = [a, b];
  f(...arr);         // f→a, f→b via spread
  for (x of arr) x() // outer→a, outer→b via iteration

Recall on Jelly micro-test fixtures: spread 0→100%, more1 0→100%.

## Implementation

- **types.ts** — 4 new interfaces: `ArrayElemBinding`,
  `SpreadArgBinding`, `ForOfBinding`, `ArrayCallbackBinding`
- **extractors/javascript.ts** — `extractArrayElemBindingsWalk` +
  `extractSpreadForOfWalk` hooked into both query and walk paths
- **points-to.ts** — array-element seeding, wildcard constraints,
  per-index spread constraints, for-of and callback constraints
- **build-edges.ts** — passes new bindings to pts map builder;
  `buildParamFlowPtsPostPass` extended to handle all pts binding types
- **wasm-worker-{protocol,entry,pool}.ts** — serializes/deserializes
  new bindings across the WASM Worker thread boundary
- **tests/** — pts unit tests + jelly-micro fixtures for spread/more1

Implement parity with the WASM JS extractor for pre-ES6 prototype OOP patterns.

Extractor (crates/codegraph-core/src/extractors/javascript.rs):
- `Foo.prototype.bar = function(){}` → emits `Foo.bar` definition (kind: method)
- `Foo.prototype.bar = identifier`   → seeds typeMap['Foo.bar'] = identifier (confidence 0.9)
- `Foo.prototype = { bar: fn, ... }` → same rules per property (pair, method_definition,
  shorthand_property_identifier)
Built-in globals (Array, Object, …) are excluded via `is_js_builtin_global` guard.
Adds 6 unit tests covering all three patterns plus edge cases.

Edge builder (crates/codegraph-core/src/edge_builder.rs):
- After a typeMap-resolved type lookup, check typeMap['TypeName.method'] for prototype
  aliases (`Foo.prototype.bar = identifierAlias`), mirroring the protoAlias fallback
  added to call-resolver.ts in the WASM path.
- Inline new-expression receiver: extract class name from `(new Foo).bar()` receivers
  using string parsing (mirrors the `^\(?\s*new\s+[A-Z...]` regex in call-resolver.ts),
  enabling resolution without a named variable binding.

Verified against the integration test in
tests/integration/prototype-method-resolution.test.ts (all 3 tests pass with native engine).

docs check acknowledged
Closes #1327

The Rust engine does not recognise Foo.prototype.bar = function(){} as a
method definition, so prototype-based method nodes were absent from the DB
when the native orchestrator ran. This causes the integration tests to fail
on all platforms where the native addon is available.

Fix two issues:
1. Remove duplicate extractPrototypeMethodsWalk call in extractSymbolsQuery
   that was inflating the definitions array (identified by Greptile)
2. Add runPostNativePrototypeMethods post-pass to native-orchestrator.ts:
   - Re-parses JS/TS files via WASM after native build
   - Inserts any method nodes missing from the DB (prototype patterns)
   - Resolves and inserts call edges to those new nodes using the WASM
     typeMap and the call-resolver

Use strip_prefix('(').unwrap_or(receiver) instead of trim_start_matches('(')
to strip at most one leading paren, matching the JS regex ^\(?. Also update
the doc comment to reflect that _ and $ prefixes are also accepted.

…es (#1331)

The newDefFiles guard restricted call scanning to only files that define
new prototype methods, silently dropping call edges from files that only
call those methods. A foo.speak() call in app.js to Foo.speak defined in
lib.js would never produce an edge. Remove the guard — the newNodeIds
check inside the loop already prevents duplicate edges. Also hoist
db.prepare() outside the loop to avoid re-preparing the same statement
on every iteration.

…1331)

…methods (JS)

Extract `fn.method = function() {}` assignments as `method` definitions in both
the query-based and walk-based JS extraction paths, enabling `this.other()` calls
inside such methods to resolve via the existing callerName-based this-dispatch
logic in `resolveByMethodOrGlobal`.

Extend the native-engine prototype backfill post-pass to also trigger on files
containing `fn.prop = function` patterns so the same resolution applies when
the Rust orchestrator runs.

Closes #1334

…arameters (JS)

Adds Phase 8.3f: when a function parameter uses object destructuring with a
rest element (`function f3({ e1: eee1, ...eerest })`), and the rest object's
property is called (`eerest.e4()`), resolve the callee via a three-hop chain:

  ObjectRestParamBinding (eerest ← f3 param 0)
  + ParamBinding          (f3(obj) → obj at index 0)
  + ObjectPropBinding     (obj = { e4 } → obj.e4 = e4)
  → pts["eerest.e4"] = {"e4"} → calls edge f3 → e4

Changes:
- types.ts: add ObjectRestParamBinding and ObjectPropBinding interfaces
- javascript.ts: extractObjectRestParamBindingsWalk (finds rest params in
  object-destructured function params) and extractObjectPropBindingsWalk
  (finds shorthand/identifier properties in object literals); wired into
  both extractSymbolsQuery and extractSymbolsWalk paths
- wasm-worker-{protocol,entry,pool}.ts: serialize new binding arrays
- points-to.ts: seed pts["rest.propName"] = {"fn"} from the three-hop chain
- build-edges.ts: new Phase 8.3f receiver-pts fallback — when a receiver call
  is unresolved, check pts["receiver.name"] for rest-dispatch targets; also
  include new bindings in buildPointsToMapForFile null-check guard

Jelly micro-test benchmark (rest fixture): recall=100% TP=1 FN=0 FP=0

Closes #1336

…eral key

`trim_matches` was stripping ALL quote chars (e.g. `"it's"` became `its`).
Replace with strip_prefix + strip_suffix to remove exactly the outermost
matching quote pair.

Both extractSymbolsQuery and extractSymbolsWalk had a second call to
extractPrototypeMethodsWalk appended at the bottom, causing prototype
methods to be extracted twice. Remove the duplicate from each path.

The duplication caused a ~44% WASM benchmark regression on the query
path (used by wasm-worker-entry.js in benchmarks).

Pick up Phase 8.3f object-rest-param and object-property binding
extraction from the base branch.

Long lines in wasm-worker-entry.ts, wasm-worker-pool.ts and two fixture
files were not wrapped per the 100-char line width rule.

The Rust engine now extracts `Foo.prototype.bar = fn` definitions
natively (PR #1327). Remove the `.prototype.` text filter from the
`runPostNativePrototypeMethods` pre-filter so those files are no longer
WASM-reparsed on every native build.

The function-as-object-property pattern (`fn.method = function(){}`)
is still not handled by Rust and continues to use the WASM post-pass.

This eliminates the 422% Build ms/file regression seen on CI.

…er-1317

useOptionalChain rewrites and formatting fixes flagged by Biome in CI.

`emit_js_prototype_method` and `extract_js_prototype_object_literal`
were emitting `complexity: None` / `cfg: None` for every function-
expression and method_definition RHS, unlike every other method/
function handler in the Rust extractor.

Call `compute_all_metrics` and `build_function_cfg` at both sites.
Add assertions to the 3 affected prototype unit tests to guard this.

Closes #1340

…ool (#1347)

…ing variable_declarator (#1331)

extractObjectRestParamBindingsWalk checked childForFieldName('name') on
every function node, but arrow_function and function_expression nodes have
no name field in the tree-sitter grammar — so const f = ({ ...rest }) => {}
always produced an undefined funcName and silently skipped the entire
parameter scan.

Fix: when childForFieldName('name') returns null and the parent node is a
variable_declarator, fall back to the declarator's own name field. This
mirrors the same pattern used in extractSpreadForOfWalk for arrow functions.

Closes the gap reported in the Greptile review (comment 3367102930).

…m-worker-entry (#1331)

paramBindings was serialized twice (lines 808 and 826 in the original code).
The second spread was a no-op since it overwrites the first with the same
value, but the duplicate caused confusion and was flagged in the Greptile
review as evidence of an incomplete field migration.

…to fix/proto-complexity-metrics-1340

… extractSpreadForOfWalk (#1359)

* test(extractor): verify exported arrow func funcStack tracking in extractSpreadForOfWalk (#1354)

Add regression tests confirming that `export const f = (arr) => { for (const x of arr) x(); }`
correctly pushes `f` onto the funcStack so for-of bindings record the right enclosing caller.
The recursive walk visits `variable_declarator` regardless of whether it is nested under a plain
`lexical_declaration` or an `export_statement`, so the gap reported in the PR #1331 review was
already closed by commit a6c5d2d. These tests document and gate that behavior.

Closes #1354

* fix: remove duplicate paramBindings in SerializedExtractorOutput, rename process identifier

The merge at 3c164f2 introduced a second `paramBindings` field (using the
top-level ParamBinding import) alongside the existing inline-import form at
line 68, causing TS2300 duplicate-identifier errors that broke every CI job.
Removed the duplicate and the now-unused ParamBinding top-level import.

Also renamed the `process` arrow-function identifier in the Phase 8.3e test
to `handleItems` — `process` is a Node.js global and its presence in the test
obscures that the test is solely about the export-wrapping code path.

… remove dup in pool (#1331)

The previous commit removed paramBindings from SerializedExtractorOutput
to fix a TS2300 duplicate-identifier error, but left two references to
ser.paramBindings in wasm-worker-pool.ts (lines 110 and 125), causing
TS2339 errors that broke every CI job.

Restore paramBindings as an inline import in the protocol interface
(matching the style of the other binding fields), and remove the
duplicate line 125 copy in pool.ts.

…ing variable_declarator (#1331)

extractObjectRestParamBindingsWalk checked childForFieldName('name') on
every function node, but arrow_function and function_expression nodes have
no name field in the tree-sitter grammar — so const f = ({ ...rest }) => {}
always produced an undefined funcName and silently skipped the entire
parameter scan.

Fix: when childForFieldName('name') returns null and the parent node is a
variable_declarator, fall back to the declarator's own name field. This
mirrors the same pattern used in extractSpreadForOfWalk for arrow functions.

Closes the gap reported in the Greptile review (comment 3367102930).

…m-worker-entry (#1331)

paramBindings was serialized twice (lines 808 and 826 in the original code).
The second spread was a no-op since it overwrites the first with the same
value, but the duplicate caused confusion and was flagged in the Greptile
review as evidence of an incomplete field migration.